const fs = require('fs');
const path = require('path');

// 添加JSON配置管理器，用于API验证
const JsonConfigManager = require('./lib/config/json-config-manager');

/**
 * 检查JSON配置文件是否存在，如果不存在则提供优雅的配置提示
 * @param {string} configDirectory - 配置文件目录
 * @returns {Object} - 配置状态对象 {isValid: boolean, reason: string, canProceed: boolean}
 */
function checkJsonConfiguration(configDirectory) {
    try {
        // 使用JsonConfigManager来查找和加载配置
        const configManager = new JsonConfigManager(configDirectory);
        const config = configManager.loadConfig();

        // 检查是否有配置的提供商
        const providers = config.providers || {};
        const hasValidProvider = Object.keys(providers).some(name => {
            const provider = providers[name];
            return provider.api_key &&
                   provider.api_key.trim() !== '' &&
                   !provider.api_key.includes('your-') &&
                   !provider.api_key.includes('-here') &&
                   provider.api_key.length > 10;
        });

        if (!hasValidProvider) {
            showWelcomeMessage();
            showJsonConfigurationInstructions(configDirectory);
            return {
                isValid: false,
                reason: 'no_valid_providers',
                canProceed: true,
                message: '没有配置有效的API密钥',
                providers: Object.keys(providers)
            };
        }

        return {
            isValid: true,
            reason: 'valid_config',
            canProceed: true,
            message: '配置有效',
            currentProvider: config.current_provider_model,
            providers: Object.keys(providers)
        };
      } catch (error) {
        showWelcomeMessage();
        showJsonConfigurationInstructions(configDirectory);
        return {
            isValid: false,
            reason: 'config_load_failed',
            canProceed: false,
            message: `配置文件加载失败: ${error.message}`
        };
    }
}

/**
 * 显示JSON配置说明
 */
function showJsonConfigurationInstructions(configDirectory) {
    const ConfigPathResolver = require('./lib/config/config-path-resolver');
    const pathResolver = new ConfigPathResolver();
    const configPath = pathResolver.getConfigFilePath();

    console.log(`
📋 Vision Analyzer 配置说明
==================================

1️⃣ 创建配置文件:
   文件位置: ${configPath}

2️⃣ 配置服务商:
   支持的服务商: tencent, moonshot, zai

3️⃣ 获取API密钥:
   • 腾讯混元: https://console.cloud.tencent.com/hunyuan
   • Moonshot: https://platform.moonshot.cn/
   • 智谱AI: https://open.bigmodel.cn/

4️⃣ 启动Web配置工具:
   运行: npm run setup
   然后访问: http://localhost:3000

💡 提示: Web配置工具可以帮您轻松完成所有配置！

==================================
    `);
}

// 保留原有的.env检查函数以保持向后兼容
function checkEnvConfiguration(projectRoot) {
    const envPath = path.join(projectRoot, '.env');
    const envExamplePath = path.join(projectRoot, '.env.example');

    // 检查.env文件是否存在
    if (!fs.existsSync(envPath)) {
        showWelcomeMessage();
        showConfigurationInstructions(projectRoot, envExamplePath);
        return {
            isValid: false,
            reason: 'missing_env_file',
            canProceed: false,
            message: '.env文件不存在'
        };
    }

    // 首先检查是否还有明显的占位符
    const envContent = fs.readFileSync(envPath, 'utf8');

    // 只检查明显的占位符，不检查具体的演示密钥
    const placeholderPatterns = [
        /your-[^-]+-api-key-here/i,
        /your-real-[^-]+-key-here/i,
        /sk-your-real-[^-]+-key-here/i,
        /YOUR_PROVIDER-YOUR_MODEL/,
        /your-email@example\.com/,
        // 检测明显的example/demo密钥
        /sk-test-demo-key/i,
        /test-api-key-demo/i
    ];

    const hasPlaceholders = placeholderPatterns.some(pattern => pattern.test(envContent));

    if (hasPlaceholders) {
        return {
            isValid: false,
            reason: 'has_placeholders',
            canProceed: true,
            message: '配置文件包含占位符，需要配置真实的API密钥',
            needWebConfig: true
        };
    }

    // 检查必要的配置项
    const requiredConfigs = [
        'current_provider_model',
        'providers'
    ];

    const providerPattern = /^([a-zA-Z0-9_-]+)=/m;
    const providers = envContent.match(providerPattern);

    if (!providers || providers.length < 2) { // 至少需要一个provider配置
        return {
            isValid: false,
            reason: 'missing_providers',
            canProceed: true,
            message: '缺少有效的服务商配置',
            needWebConfig: true
        };
    }

    // 检查是否有任何有效的provider配置
    const validProviders = [];
    const providerConfigPattern = /^([a-zA-Z0-9_-]+)=({.*})$/gm;
    let match;

    while ((match = providerConfigPattern.exec(envContent)) !== null) {
        const [, providerName, configStr] = match;

        if (providerName !== 'current_provider_model' && providerName !== 'providers') {
            try {
                const config = JSON.parse(configStr);
                const apiKey = config.api_key;

                // 检查API密钥是否存在且看起来合理（长度 > 10）
                if (apiKey && typeof apiKey === 'string' && apiKey.length > 10) {
                    validProviders.push(providerName);
                }
            } catch (e) {
                // 忽略解析错误
            }
        }
    }

    if (validProviders.length === 0) {
        return {
            isValid: false,
            reason: 'no_valid_providers',
            canProceed: true,
            message: '没有配置有效的服务商API密钥',
            needWebConfig: true
        };
    }

    return {
        isValid: true,
        reason: 'valid',
        canProceed: true,
        message: '配置完整有效',
        validProviders: validProviders
    };
}

/**
 * 显示欢迎信息
 */
function showWelcomeMessage() {
    console.log('\n🎉 欢迎使用 Vision Analyzer MCP Server！');
    console.log('═══════════════════════════════════════════════════════════════\n');
    console.log('🚀 这是一个强大的视觉分析 MCP 服务器，支持多种视觉理解功能：');
    console.log('   • 设计截图分析');
    console.log('   • 组件层次结构提取');
    console.log('   • 精确布局规格识别');
    console.log('   • 设计令牌提取');
    console.log('   • 通用图像理解\n');
}

/**
 * 显示配置说明
 */
function showConfigurationInstructions(projectRoot, envExamplePath) {
    console.log('📋 首次使用需要配置 LLM 服务提供商：\n');

    if (fs.existsSync(envExamplePath)) {
        console.log('✅ 推荐方式：复制配置模板');
        console.log('   1️⃣ 复制配置文件：');
        console.log(`      cp ${path.relative(projectRoot, envExamplePath)} .env\n`);
        console.log('   2️⃣ 编辑 .env 文件，填入您的 API 密钥：');
        console.log('      • Moonshot: https://platform.moonshot.cn/');
        console.log('      • 腾讯混元: https://console.cloud.tencent.com/hunyuan');
        console.log('      • 智谱AI: https://open.bigmodel.cn/\n');
    } else {
        console.log('❌ 配置模板文件不存在，请手动创建 .env 文件\n');
    }

    console.log('💡 快速开始指南：');
    console.log('   • 方式1：运行交互式配置向导 npm run setup');
    console.log('   • 方式2：手动编辑 .env 文件中的 "your-*-api-key-here" 部分');
    console.log('   • 设置 current_provider_model 选择默认服务商');
    console.log('   • 保存文件后重新运行程序\n');

    console.log('📚 详细文档：');
    console.log('   • README.md - 完整使用说明');
    console.log('   • .env.example - 配置示例\n');
}

/**
 * 显示配置不完整消息
 */
function showIncompleteConfigurationMessage(projectRoot, envExamplePath) {
    console.log('\n⚠️  检测到配置文件需要完善');
    console.log('═══════════════════════════════════════════════════════════════\n');
    console.log('🔧 请完善以下配置项：\n');
    console.log('   方式1：运行交互式配置向导 npm run setup');
    console.log('   方式2：');
    console.log('   1️⃣ 在 .env 文件中找到 "your-*-api-key-here"');
    console.log('   2️⃣ 替换为您的实际 API 密钥');
    console.log('   3️⃣ 确保选择了合适的 current_provider_model\n');

    if (fs.existsSync(envExamplePath)) {
        console.log('📖 参考配置模板：');
        console.log(`   ${path.relative(projectRoot, envExamplePath)}\n`);
    }
}

/**
 * 显示缺失服务商配置消息
 */
function showMissingProvidersMessage(projectRoot, envExamplePath) {
    console.log('\n❌ 缺少必要的 LLM 服务商配置');
    console.log('═══════════════════════════════════════════════════════════════\n');
    console.log('🔧 需要配置至少一个 LLM 服务商：\n');

    if (fs.existsSync(envExamplePath)) {
        console.log('💡 建议重新生成配置文件：');
        console.log(`   1️⃣ 备份当前配置：mv .env .env.backup`);
        console.log(`   2️⃣ 复制模板：cp ${path.relative(projectRoot, envExamplePath)} .env`);
        console.log('   3️⃣ 重新配置 API 密钥\n');
    }
}

/**
 * 显示配置成功消息
 */
function showConfigurationSuccess() {
    const envPath = path.join(process.cwd(), '.env');

    // 读取当前配置
    let currentProvider = '未知';
    let providers = [];

    try {
        const envContent = fs.readFileSync(envPath, 'utf8');
        const providerMatch = envContent.match(/current_provider_model=([^\n\r]+)/);
        if (providerMatch) {
            currentProvider = providerMatch[1];
        }

        const providersMatch = envContent.match(/providers=\[([^\]]+)\]/);
        if (providersMatch) {
            providers = JSON.parse(providersMatch[0].split('=')[1]);
        }
    } catch (error) {
        // 忽略读取错误
    }

    console.log('\n✅ 配置检查通过！');
    console.log('═══════════════════════════════════════════════════════════════\n');
    console.log('🎯 当前配置：');
    console.log(`   • 默认服务商: ${currentProvider}`);
    console.log(`   • 可用服务商: ${providers.join(', ')}`);
    console.log('   • MCP 服务器已就绪\n');
}

module.exports = {
    checkEnvConfiguration, // 保留向后兼容
    checkJsonConfiguration, // 新的JSON配置检查
    showConfigurationSuccess
};